<html>
<body>
<p>The JSPON browser is a free, open-source tool for browsing and manipulated JSPON persisted 
object graphs/data sources. The JSPON browser can be found at www.jspon.org/browser.html 
or downloaded at www.jspon.org/files/browser.zip . JSPON is a JSON extension for robust access 
and manipulation of persisted objects that includes definitions for how to support object and array 
identification, referencing, lazy loading/partial graph transfer, object modification, prototype 
definition, and more. The JSPON specification can be found at www.jspon.org.
</p>
<p>
You can start the browser by opening browser.html in your browser. There is sample JSPON data 
that comes with the browser. When the browser asks what object you want to open, enter "SampleData".
You can then see some examples of the expressive capabilities of the JSPON. There are further examples
that can be access on the jspon website. Using the JSPON browser, you can load the object
http://www.jspon.org/browser.html?id=dyna%2F100788 (or http://www.xucia.com/browser.html?id=dyna%2F100788
if you are using Adblock/filterset G which blocks jspon for some reason). The following properties of the root 
object from the example url illustrate some of the major aspects of 
JSPON:</d
<UL>
  <LI>types - Just the different types of values that 
  can be transferred with good 'ol JSON: string, boolean, number, array/list, 
  object, and null. This includes a real date object (defined by 
  JSPON).</LI>
  <LI>referencing - This should hows 
  identification/referencing allows circular referencing and multiple references 
  to single objects. This is a graph of the Doe family, and the properties refer 
  to the family members by relation, but since the objects are 
  referenced&nbsp;not just copied, the graph can be infinitely recursively 
  drilled down, and&nbsp;it is still the same objects that are being 
  accessed.</LI>
  <LI>lazyLoading - This can be seen when drilling into 
  any part of the persisted graph that has not been loaded yet, but this 
  property references a larger set of the graph, and you can see how values are 
  loaded into the graph as needed. JSPON provides definition for the 
  identification and lazy endpoints so this client browser can provide lazy 
  loading for any JSPON data source.</LI>
  <LI>inheritance - This is an object that is defined to 
  inherit properties from another object.&nbsp;This object is inheriting from 
  the object referred by the type&nbsp;property.&nbsp;In other words the object 
  with the id of <A href="http://www.xucia.com/dyna/107650">dyna/107650</A> has 
  a prototype or delegate that is the object with the id of <A 
  href="http://www.xucia.com/dyna/107653">dyna/107653</A>. If a property is 
  changed or added in the delegate object, they will be reflected in the 
  instance object, unless the instance object defines that property. In this 
  case the stringField property is defined in the instance and all the other 
  properties are inherited from the delegate object. The basis property refers 
  to the delegate/prototype object. The browser provides coloring to help know 
  what is inherited and what is not.</LI>
  <LI>modifiableData - This object has been defined by 
  the server to be publicly modifiable, so you can create and modify objects on 
  my server. You can go ahead and add new properties and modify values in this 
  object. You can delete properties if it looks like there is plenty of other 
  ones, but please refrain from deleting all the properties, we want to keep it 
  fun for everyone. You can modify properties and watch your HTTP traffic to see 
  how the object modifications are sent back to the server. You can view the 
  headers (the Access-Level header) to see how the definitions for access levels 
  is transferred to the client from the server. Of course, a server shouldn't 
  and this server doesn't count on the client to enforce the access levels, but 
  maintains it's own security as well.</LI>
  <UL>
    <LI>structuredObject - This object has a structure 
    definition, in the structure property (provided that no one has deleted it, 
    it is publicly modifiable), and it is defined to allow only a string value 
    in the stringOnly field, and only a number in the numberOnly. You can try to 
    change value of the numberOnly property to have letters in it, and it should 
    complain.</LI></UL>
  <LI>crossDomain - The browser supports the <A 
  href="http://bob.pythonmac.org/archives/2005/12/05/remote-json-jsonp/">JSON-P 
  protocol </A>for cross domain transfer, so this persisted object graph 
  actually spans domains, and references objects from another host within the 
  graph. Of course, the usual warnings about using cross-domain dynamic scripts 
  applies, you don't want to use the browser to connect your high-security 
  objects with an untrusted source using JSON-P, but rather use a proxy, but in 
  this case the foreign host is one of my own domains (<A 
  href="http://www.authenteo.com">www.authenteo.com</A>), so it is trustworthy. 
  This property refers to a list persitent objects that represent the pages on 
  my www.authenteo.com site. Having persisted object graphs that span domains 
  can make mashups have a much more consistent object model.</LI>
  <LI>differentSources - This object references to JSPON 
  objects that represent different source mediums. There is a SQL database 
  (HSQL), an XML file, and an RSS source. The server can expose all of these 
  data sources as JSPON, and they can even be modified using the JSPON browser, 
  and server can make the appropriate SQL updates, or XML file changes (OK, the 
  RSS isn't modifiable, and <STRONG>you</STRONG> can't modify any of these data 
  sources, because I haven't given you that access level). This demonstrates the 
  flexibility of JSPON as persistence protocol for different mediums of data 
  (and it also demonstrates the capabilites of the Jsponic server that is being 
  used). If you want access to modify the SQL tables, or the XML files, let me 
  know, and I can set you up with an account.</LI>
  <LI>perseverePreview - This is all built with my soon to be released Persevere Ajax 
  persistence framework which maps remotely persisted data to JavaScript objects 
  in the browser with <A 
  href="http://tunes.org/wiki/Orthogonal_Persistence">orthogonal 
  persistence</A>. This property refers to a persisted function object that 
  gives a little preview, and uses the persistence mapped objects&nbsp;to access 
  a persisted property (this.referencing.wife.name). When accessing properties, 
  the framework will transparently perform lazy loading through JSPON of any 
  data that has not been transferred. Then the function sets a new value in 
  this.modifiableData.randomNumber. This value is automatically persisted to the 
  server and should be available if you come back to the page later (if someone 
  else hasn't changed it). Since the data is mapped to JS objects, you can also 
  look at this object graph in JS debugger (like Firebug). Add a watch for the 
  global variable "rootObject". The debugger won't be capable of lazy loading, 
  but you can see everything that has been downloaded.</LI></UL>
<DIV>The server is the Jsponic server (JSPON server) that 
will also be released soon, but the purpose of this tool is to make the communication protocol visible and open so 
others can review and hopefully implement it in other technologies.</DIV>
<DIV>&nbsp;</DIV>
<DIV>If anyone would like their own account on my object 
server, and their own access controlled persistent object graph, just let me 
know and I will set you up (<A 
href="mailto:kriszyp@xucia.com">kriszyp@xucia.com</A>).</DIV>
</body></html>